// Rust智能助手机器人界面
class RobotAssistant {
    constructor() {
        this.recognition = null;
        this.isRecording = false;
        this.isLoading = false;
        this.ttsEnabled = true; // 默认开启语音播报
        this.synthesis = null;
        this.currentUtterance = null;
        this.welcomePlayed = false; // 标记欢迎语是否已播放
        this.isStartingChat = false; // 标记是否从"开始对话"按钮触发
        this.sendTimeout = null; // 延迟发送定时器
        this.lastFinalTranscript = ''; // 最后一次最终识别结果
        this.silenceDelay = 3000; // 静默延迟时间（毫秒），默认3秒
        this.init();
    }

    init() {
        this.initSpeechSynthesis();
        this.bindEvents();
        this.initSpeechRecognition();
        this.loadTtsSetting();
        this.focusInput();
        
        // 延迟播放欢迎语，确保页面加载完成
        // 某些浏览器需要用户交互后才能播放，所以延迟更长时间
        setTimeout(() => {
            this.playWelcomeMessage();
        }, 1500);
        
        // 如果第一次尝试失败，在用户点击页面后再试一次
        // 这是因为某些浏览器的自动播放策略
        let clickHandler = null;
        const tryPlayOnClick = () => {
            if (!this.welcomePlayed && this.ttsEnabled && this.synthesis) {
                console.log('用户点击页面，尝试播放欢迎语');
                this.playWelcomeMessage();
                if (clickHandler) {
                    document.removeEventListener('click', clickHandler);
                    document.removeEventListener('touchstart', clickHandler);
                    clickHandler = null;
                }
            }
        };
        
        // 如果3秒后还没播放，等待用户点击
        setTimeout(() => {
            if (!this.welcomePlayed && this.ttsEnabled && this.synthesis) {
                console.log('等待用户交互后播放欢迎语（点击页面任意位置）');
                clickHandler = tryPlayOnClick;
                // 监听整个文档的点击事件
                document.addEventListener('click', clickHandler, { once: true });
                // 也监听触摸事件（移动端）
                document.addEventListener('touchstart', clickHandler, { once: true });
            }
        }, 3000);
        
        // 添加一个提示，告诉用户如果没听到欢迎语可以点击按钮
        setTimeout(() => {
            if (!this.welcomePlayed && this.ttsEnabled && this.synthesis) {
                console.log('提示：如果未听到欢迎语，可以点击"欢迎语"按钮手动播放');
            }
        }, 4000);
    }

    bindEvents() {
        const startChatBtn = document.getElementById('startChatBtn');

        // 开始对话按钮
        if (startChatBtn) {
            startChatBtn.addEventListener('click', () => {
                this.startChat();
            });
        }

        // 如果输入区域已存在，绑定事件
        const input = document.getElementById('robotInput');
        if (input) {
            this.bindInputEvents();
        }

        // 语音播报开关
        const ttsToggleBtn = document.getElementById('ttsToggleBtn');
        if (ttsToggleBtn) {
            ttsToggleBtn.addEventListener('click', () => {
                this.toggleTts();
            });
        }
    }

    initSpeechSynthesis() {
        // 检查浏览器是否支持语音合成
        if ('speechSynthesis' in window) {
            this.synthesis = window.speechSynthesis;
            
            // 获取可用的语音列表（用于调试）
            this.synthesis.onvoiceschanged = () => {
                const voices = this.synthesis.getVoices();
                console.log('可用语音列表:', voices.length);
                
                // 列出所有中文语音供调试
                const chineseVoices = voices.filter(voice => 
                    voice.lang.includes('zh') || voice.lang.includes('CN')
                );
                console.log('中文语音列表:', chineseVoices.map(v => `${v.name} (${v.lang})`));
                
                // 如果语音列表加载完成且欢迎语还没播放，尝试播放
                if (!this.welcomePlayed && this.ttsEnabled) {
                    setTimeout(() => {
                        this.playWelcomeMessage();
                    }, 500);
                }
            };
            
            // 立即尝试获取语音列表（某些浏览器需要）
            const voices = this.synthesis.getVoices();
            if (voices.length > 0) {
                console.log('语音列表已加载:', voices.length);
                // 列出中文语音
                const chineseVoices = voices.filter(voice => 
                    voice.lang.includes('zh') || voice.lang.includes('CN')
                );
                if (chineseVoices.length > 0) {
                    console.log('找到中文语音:', chineseVoices.map(v => v.name));
                }
            }
        } else {
            console.warn('浏览器不支持语音合成功能');
            const ttsToggleBtn = document.getElementById('ttsToggleBtn');
            if (ttsToggleBtn) {
                ttsToggleBtn.style.display = 'none';
            }
        }
    }

    playWelcomeMessage(force = false) {
        // 如果是手动点击播放，清除标记允许重新播放
        if (force) {
            sessionStorage.removeItem('robotWelcomePlayed');
            this.welcomePlayed = false;
        } else {
            // 自动播放时，检查是否已经播放过
            const hasPlayed = sessionStorage.getItem('robotWelcomePlayed');
            if (hasPlayed === 'true') {
                console.log('欢迎语已播放过，跳过自动播放');
                return;
            }
        }
        
        if (!this.ttsEnabled) {
            console.log('语音播报已关闭，无法播放欢迎语');
            if (force) {
                alert('请先开启语音播报功能');
            }
            return;
        }
        
        if (!this.synthesis) {
            console.warn('语音合成未初始化，无法播放欢迎语');
            if (force) {
                alert('您的浏览器不支持语音播报功能');
            }
            return;
        }
        
        console.log('准备播放欢迎语...');
        const welcomeText = '欢迎进入Rust智能辅助平台，我是你的专属学习助手。';
        
        // 尝试播放欢迎语
        try {
            this.speak(welcomeText);
            // 标记已播放（仅在自动播放时）
            if (!force) {
                sessionStorage.setItem('robotWelcomePlayed', 'true');
            }
            this.welcomePlayed = true;
            console.log('欢迎语播放成功');
        } catch (error) {
            console.error('播放欢迎语失败:', error);
            if (force) {
                alert('播放欢迎语失败，请检查浏览器设置');
            }
        }
    }

    speak(text, options = {}) {
        if (!this.synthesis || !this.ttsEnabled) {
            console.log('语音播报条件不满足:', {
                hasSynthesis: !!this.synthesis,
                ttsEnabled: this.ttsEnabled
            });
            return;
        }

        // 停止当前播放
        this.stopSpeaking();

        // 清理文本（移除Markdown标记、HTML标签等）
        const cleanText = this.cleanTextForSpeech(text);

        if (!cleanText.trim()) {
            console.log('清理后的文本为空，跳过播报');
            return;
        }

        console.log('开始语音播报:', cleanText.substring(0, 50) + '...');

        const utterance = new SpeechSynthesisUtterance(cleanText);
        
        // 设置语音参数 - 优化为更自然、科技感的人声
        utterance.lang = options.lang || 'zh-CN';
        utterance.rate = options.rate || 0.92; // 语速稍慢，更自然流畅 (0.1-10)
        utterance.pitch = options.pitch || 1.15; // 音调稍高，更清晰有科技感 (0-2)
        utterance.volume = options.volume || 0.95; // 音量稍低，更柔和 (0-1)

        // 智能选择最佳中文语音（优先选择Neural语音，更自然的人声）
        const voices = this.synthesis.getVoices();
        console.log('可用语音数量:', voices.length);
        
        // 筛选所有中文语音
        const chineseVoices = voices.filter(voice => 
            voice.lang.includes('zh') || voice.lang.includes('CN')
        );
        
        let chineseVoice = null;
        
        // 第一优先级：Neural语音（最自然的人声，科技感强）
        const neuralVoices = chineseVoices.filter(voice => 
            voice.name.includes('Neural') || voice.name.includes('neural')
        );
        
        if (neuralVoices.length > 0) {
            // 优先选择女声Neural语音（通常更清晰自然）
            chineseVoice = neuralVoices.find(voice => 
                voice.name.includes('Xiaoxiao') || voice.name.includes('Xiaoyi') ||
                voice.name.includes('Xiaohan') || voice.name.includes('Xiaomo') ||
                voice.name.includes('Xiaoxuan') || voice.name.includes('Xiaorui')
            ) || neuralVoices.find(voice => 
                voice.name.includes('Yunxi') || voice.name.includes('Yunyang')
            ) || neuralVoices[0]; // 如果都没有，选择第一个Neural语音
            
            console.log('找到Neural语音:', neuralVoices.map(v => v.name));
        }
        
        // 第二优先级：Premium/Enhanced语音
        if (!chineseVoice) {
            chineseVoice = chineseVoices.find(voice => 
                voice.name.includes('Premium') || voice.name.includes('premium') ||
                voice.name.includes('Enhanced') || voice.name.includes('enhanced')
            );
        }
        
        // 第三优先级：特定名称的语音（通常是较好的语音）
        if (!chineseVoice) {
            chineseVoice = chineseVoices.find(voice => 
                voice.name.includes('Xiaoxiao') || voice.name.includes('Xiaoyi') ||
                voice.name.includes('Yunxi') || voice.name.includes('Yunyang') ||
                voice.name.includes('Xiaohan') || voice.name.includes('Xiaomo') ||
                voice.name.includes('Xiaoxuan') || voice.name.includes('Xiaorui')
            );
        }
        
        // 第四优先级：任何中文语音
        if (!chineseVoice && chineseVoices.length > 0) {
            chineseVoice = chineseVoices[0];
        }
        
        if (chineseVoice) {
            utterance.voice = chineseVoice;
            const voiceType = chineseVoice.name.includes('Neural') ? 'Neural(科技感人声)' : 
                            chineseVoice.name.includes('Premium') ? 'Premium(高级人声)' :
                            chineseVoice.name.includes('Enhanced') ? 'Enhanced(增强人声)' : '标准';
            console.log('使用中文语音:', chineseVoice.name, '| 类型:', voiceType);
        } else {
            console.warn('未找到中文语音，使用默认语音');
        }

        // 事件处理
        utterance.onstart = () => {
            console.log('语音播报开始');
            this.updateRobotStatus('正在播报...');
        };

        utterance.onend = () => {
            console.log('语音播报结束');
            this.updateRobotStatus('就绪');
            this.currentUtterance = null;
        };

        utterance.onerror = (event) => {
            console.error('语音播报错误:', event.error);
            this.updateRobotStatus('播报错误');
            this.currentUtterance = null;
        };

        this.currentUtterance = utterance;
        
        try {
            this.synthesis.speak(utterance);
            console.log('已调用speak方法');
        } catch (error) {
            console.error('调用speak方法失败:', error);
        }
    }

    stopSpeaking() {
        if (this.synthesis && this.synthesis.speaking) {
            this.synthesis.cancel();
            this.currentUtterance = null;
        }
    }
    
    extractContentAfterGreeting(text) {
        if (!text) return '';
        
        // 去除首尾空格
        text = text.trim();
        if (!text) return '';
        
        // 将文本转为小写进行匹配（不区分大小写）
        const lowerText = text.toLowerCase();
        
        // 查找所有"你好"的位置
        const greetingIndex = lowerText.indexOf('你好');
        
        // 如果没有找到"你好"，直接返回原文本
        if (greetingIndex === -1) {
            return text;
        }
        
        // 找到"你好"之后的内容
        let afterGreeting = text.substring(greetingIndex + 2).trim();
        
        // 移除"你好"后的标点符号和空格
        afterGreeting = afterGreeting.replace(/^[，,。.！!？?\s]+/, '').trim();
        
        // 如果"你好"后面没有内容，说明只有"你好"
        if (!afterGreeting || afterGreeting.length === 0) {
            return ''; // 返回空字符串，表示只有问候语
        }
        
        // 检查是否只是重复的"你好"（如"你好你好"、"你好，你好"）
        const cleanedAfterGreeting = afterGreeting.toLowerCase().replace(/[，,。.！!？?\s]/g, '');
        if (cleanedAfterGreeting === '你好' || cleanedAfterGreeting === '你好你好') {
            return ''; // 只有"你好"，返回空字符串
        }
        
        // 如果"你好"在开头，直接返回后面的内容
        if (greetingIndex === 0) {
            return afterGreeting;
        }
        
        // 如果"你好"不在开头，检查"你好"前面是否只有空格和标点
        const beforeGreeting = text.substring(0, greetingIndex).trim();
        const cleanedBefore = beforeGreeting.replace(/[，,。.！!？?\s]/g, '');
        
        // 如果"你好"前面没有实际内容，返回"你好"后面的内容
        if (cleanedBefore.length === 0) {
            return afterGreeting;
        }
        
        // 如果"你好"前面有内容，返回"你好"后面的内容（忽略前面的内容）
        return afterGreeting;
    }

    cleanTextForSpeech(text) {
        if (!text) return '';
        
        // 移除HTML标签
        let clean = text.replace(/<[^>]*>/g, '');
        
        // 先移除代码块、链接等不相关内容
        clean = clean
            .replace(/```[\s\S]*?```/g, '') // 代码块
            .replace(/`[^`]+`/g, '') // 行内代码
            .replace(/\[([^\]]+)\]\([^\)]+\)/g, '$1') // 链接，保留文本
            .replace(/!\[([^\]]*)\]\([^\)]+\)/g, ''); // 图片
        
        // 提取概念定义和核心要点
        const extractedParts = [];
        const seen = new Set(); // 用于去重
        
        // 1. 提取概念定义（匹配"X是指"、"X是"等模式）
        // 匹配粗体概念名 + 定义
        const boldDefinitionPattern = /\*\*([^*]+)\*\*\s*(?:是指|是|指的是|定义为|的定义是|的定义为)\s*([^。！？\n]{10,200}[。！？])/g;
        let match;
        while ((match = boldDefinitionPattern.exec(clean)) !== null) {
            const concept = match[1].trim();
            const definition = match[2].trim();
            const key = `${concept}:${definition}`;
            if (!seen.has(key) && !definition.includes('http') && !definition.match(/^[a-zA-Z0-9_\s]+$/)) {
                extractedParts.push(`${concept}是指${definition}`);
                seen.add(key);
            }
        }
        
        // 匹配普通文本中的定义模式
        const definitionPattern = /([^。！？\n]{1,30})(?:是指|是|指的是|定义为|的定义是|的定义为)\s*([^。！？\n]{10,200}[。！？])/g;
        while ((match = definitionPattern.exec(clean)) !== null) {
            const concept = match[1].trim();
            const definition = match[2].trim();
            // 跳过明显不是概念的（包含特殊字符、过长等）
            if (concept.length > 1 && concept.length < 30 && 
                !concept.includes('```') && !concept.includes('http') &&
                !concept.match(/^[a-zA-Z0-9_\s]+$/) && !definition.includes('http')) {
                const key = `${concept}:${definition}`;
                if (!seen.has(key)) {
                    extractedParts.push(`${concept}是指${definition}`);
                    seen.add(key);
                }
            }
        }
        
        // 2. 提取核心要点（列表项）
        const listPattern = /(?:^|\n)(?:\s*[-*+]\s+|\s*\d+[\.、]\s+)([^\n]{5,150})/gm;
        while ((match = listPattern.exec(clean)) !== null) {
            let item = match[1].trim();
            // 移除Markdown标记
            item = item
                .replace(/\*\*([^*]+)\*\*/g, '$1')
                .replace(/\*([^*]+)\*/g, '$1')
                .replace(/`([^`]+)`/g, '$1');
            
            // 过滤掉代码、链接、示例等
            if (item && !item.includes('```') && !item.includes('http') && 
                !item.match(/^[a-zA-Z0-9_\s]+$/) && 
                !item.includes('代码示例') && !item.includes('示例代码') &&
                !item.includes('请看') && !item.includes('参考')) {
                const key = `list:${item}`;
                if (!seen.has(key)) {
                    extractedParts.push(item);
                    seen.add(key);
                }
            }
        }
        
        // 3. 提取包含"要点"、"关键"、"核心"等关键词的段落
        const keyPointPattern = /([^。！？\n]{5,200}(?:要点|关键|核心|重点|主要|重要)[^。！？\n]{5,200}[。！？])/g;
        while ((match = keyPointPattern.exec(clean)) !== null) {
            let keyPoint = match[1].trim();
            // 移除Markdown标记
            keyPoint = keyPoint
                .replace(/\*\*([^*]+)\*\*/g, '$1')
                .replace(/\*([^*]+)\*/g, '$1')
                .replace(/`([^`]+)`/g, '$1');
            
            if (!keyPoint.includes('```') && !keyPoint.includes('http')) {
                const key = `keypoint:${keyPoint}`;
                if (!seen.has(key)) {
                    extractedParts.push(keyPoint);
                    seen.add(key);
                }
            }
        }
        
        // 4. 如果没有提取到内容，提取前2-3个段落（可能是定义）
        if (extractedParts.length === 0) {
            const paragraphs = clean.split(/\n\n+/).filter(p => {
                const trimmed = p.trim();
                return trimmed.length > 10 && 
                       !trimmed.includes('```') && 
                       !trimmed.includes('http') &&
                       !trimmed.match(/^[a-zA-Z0-9_\s]+$/);
            });
            
            for (let i = 0; i < Math.min(3, paragraphs.length); i++) {
                let para = paragraphs[i].trim();
                // 移除Markdown标记
                para = para
                    .replace(/#{1,6}\s+/g, '')
                    .replace(/\*\*([^*]+)\*\*/g, '$1')
                    .replace(/\*([^*]+)\*/g, '$1')
                    .replace(/`([^`]+)`/g, '$1');
                
                // 限制段落长度
                if (para.length > 300) {
                    para = para.substring(0, 300) + '...';
                }
                
                extractedParts.push(para);
            }
        }
        
        // 合并提取的内容
        let result = extractedParts.filter(p => p && p.trim().length > 0).join('。');
        
        // 如果没有提取到任何内容，返回空字符串（不播报）
        if (!result || result.trim().length === 0) {
            return '';
        }
        
        // 移除emoji和多余标记
        result = result
            .replace(/🦀|🌟|🚀|💡|📚|💻|🔄|🎯|📖|🔧|✅|❌|⚠️|ℹ️|🔗|🧠|📄|📊|🤖/g, '')
            .replace(/\n+/g, '，')
            .replace(/\s+/g, ' ')
            .trim();
        
        // 优化标点符号
        result = result
            .replace(/，+/g, '，')
            .replace(/。+/g, '。')
            .replace(/！+/g, '！')
            .replace(/？+/g, '？')
            .replace(/：+/g, '：')
            .replace(/；+/g, '；');
        
        // 确保以句号结尾
        if (result && !result.match(/[。！？]$/)) {
            result += '。';
        }
        
        // 限制长度（最多500字）
        if (result.length > 500) {
            const truncated = result.substring(0, 500);
            const lastPeriod = truncated.lastIndexOf('。');
            if (lastPeriod > 300) {
                result = truncated.substring(0, lastPeriod + 1);
            } else {
                result = truncated + '...';
            }
        }
        
        return result;
    }

    toggleTts() {
        this.ttsEnabled = !this.ttsEnabled;
        this.updateTtsButton();
        this.saveTtsSetting();
        
        if (!this.ttsEnabled) {
            this.stopSpeaking();
        }
        
        // 显示提示
        const status = this.ttsEnabled ? '已开启' : '已关闭';
        this.updateRobotStatus(`语音播报${status}`);
        setTimeout(() => {
            if (!this.isRecording && !this.isLoading) {
                this.updateRobotStatus('就绪');
            }
        }, 2000);
    }

    updateTtsButton() {
        const ttsToggleBtn = document.getElementById('ttsToggleBtn');
        if (!ttsToggleBtn) return;

        const icon = ttsToggleBtn.querySelector('i');
        const label = ttsToggleBtn.querySelector('.tts-label');
        
        if (this.ttsEnabled) {
            ttsToggleBtn.classList.add('active');
            if (icon) icon.className = 'fas fa-volume-up';
            if (label) label.textContent = '语音播报';
        } else {
            ttsToggleBtn.classList.remove('active');
            if (icon) icon.className = 'fas fa-volume-mute';
            if (label) label.textContent = '已关闭';
        }
    }

    saveTtsSetting() {
        localStorage.setItem('robotTtsEnabled', this.ttsEnabled.toString());
    }

    loadTtsSetting() {
        const saved = localStorage.getItem('robotTtsEnabled');
        if (saved !== null) {
            this.ttsEnabled = saved === 'true';
        }
        this.updateTtsButton();
    }

    initSpeechRecognition() {
        const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
        
        if (!SpeechRecognition) {
            console.warn('浏览器不支持语音识别');
            const voiceBtn = document.getElementById('robotVoiceBtn');
            if (voiceBtn) {
                voiceBtn.style.display = 'none';
            }
            return;
        }

        this.recognition = new SpeechRecognition();
        this.recognition.lang = 'zh-CN';
        this.recognition.continuous = true; // 持续聆听，不会因为短暂停顿就结束
        this.recognition.interimResults = true; // 返回临时结果

        this.recognition.onstart = () => {
            this.isRecording = true;
            this.updateVoiceButton(true);
            this.updateRobotStatus('正在聆听...', true);
            
            // 如果正在播报，先停止
            if (this.synthesis && this.synthesis.speaking) {
                this.stopSpeaking();
            }
        };

        this.recognition.onresult = (event) => {
            let fullTranscript = '';
            
            // 在持续模式下，收集所有识别结果（从开始到当前）
            // event.results 包含所有结果，每个结果都有 transcript 和 isFinal 属性
            for (let i = 0; i < event.results.length; i++) {
                fullTranscript += event.results[i][0].transcript;
            }
            
            // 获取最后的结果（可能是临时或最终）
            const lastResult = event.results[event.results.length - 1];
            const isFinal = lastResult.isFinal;
            
            if (fullTranscript && fullTranscript.trim().length > 0) {
                // 处理"你好"后的内容提取
                let processedTranscript = this.extractContentAfterGreeting(fullTranscript);
                
                // 如果处理后为空，说明只有"你好"
                if (!processedTranscript || processedTranscript.trim().length === 0) {
                    processedTranscript = '你好';
                }
                
                // 更新输入框显示（实时显示识别结果，包括临时和最终结果）
                const input = document.getElementById('robotInput');
                if (input) {
                    input.value = processedTranscript;
                }
                
                if (isFinal) {
                    // 最终结果，保存当前完整识别内容
                    this.lastFinalTranscript = processedTranscript;
                    
                    // 清除之前的延迟发送定时器（用户继续说话，重置计时）
                    if (this.sendTimeout) {
                        clearTimeout(this.sendTimeout);
                        this.sendTimeout = null;
                    }
                    
                    // 更新状态，提示用户可以说更多内容
                    this.updateRobotStatus(`已识别，${this.silenceDelay / 1000}秒后自动发送（继续说话可延长）...`, true);
                    
                    // 设置延迟发送：等待一段时间（默认3秒），如果期间没有新的最终结果，则发送消息
                    this.sendTimeout = setTimeout(() => {
                        if (this.lastFinalTranscript && this.lastFinalTranscript.trim().length > 0) {
                            this.sendRecognizedMessage(this.lastFinalTranscript);
                            this.sendTimeout = null;
                            this.lastFinalTranscript = '';
                        }
                    }, this.silenceDelay);
                } else {
                    // 临时结果，实时更新状态
                    this.updateRobotStatus('正在聆听...', true);
                }
            }
        };

        this.recognition.onend = () => {
            // 如果还有待发送的内容，立即发送
            if (this.lastFinalTranscript && this.lastFinalTranscript.trim().length > 0) {
                // 清除延迟定时器
                if (this.sendTimeout) {
                    clearTimeout(this.sendTimeout);
                    this.sendTimeout = null;
                }
                // 立即发送最后识别的消息
                this.sendRecognizedMessage(this.lastFinalTranscript);
                this.lastFinalTranscript = '';
            }
            
            this.isRecording = false;
            this.updateVoiceButton(false);
            
            // 如果是从"开始对话"触发的，且没有识别到结果，显示浮动输入框
            if (this.isStartingChat && !this.isLoading) {
                this.isStartingChat = false;
                // 检查是否有用户消息（如果有，说明识别成功并已发送）
                const messagesContainer = document.getElementById('chatMessages');
                const userMessages = messagesContainer?.querySelectorAll('.user-message');
                if (!userMessages || userMessages.length === 0) {
                    // 没有用户消息，说明识别失败或用户没有说话，显示浮动输入框
                    this.showFloatingInput();
                }
            }
            
            if (!this.isLoading) {
                this.updateRobotStatus('就绪');
            }
        };

        this.recognition.onerror = (event) => {
            console.error('语音识别错误:', event.error);
            this.isRecording = false;
            this.updateVoiceButton(false);
            this.updateRobotStatus('识别失败');
            
            // 如果是从"开始对话"触发的，显示浮动输入框
            if (this.isStartingChat) {
                this.isStartingChat = false;
                // 只有非用户取消的错误才显示输入框
                if (event.error !== 'no-speech' && event.error !== 'aborted') {
                    this.showFloatingInput();
                } else {
                    // 用户没有说话或取消，恢复状态
                    this.showStartChatButton();
                }
            }
            
            setTimeout(() => {
                if (!this.isLoading) {
                    this.updateRobotStatus('就绪');
                }
            }, 2000);
        };
    }

    toggleVoiceInput() {
        if (!this.recognition) {
            alert('您的浏览器不支持语音识别功能');
            return;
        }

        // 如果正在播报，先停止
        if (this.synthesis && this.synthesis.speaking) {
            this.stopSpeaking();
        }

        if (this.isRecording) {
            // 停止录音时，如果有待发送的内容，立即发送
            if (this.lastFinalTranscript && this.lastFinalTranscript.trim().length > 0) {
                // 清除延迟定时器
                if (this.sendTimeout) {
                    clearTimeout(this.sendTimeout);
                    this.sendTimeout = null;
                }
                // 立即发送最后识别的消息
                this.sendRecognizedMessage(this.lastFinalTranscript);
                this.lastFinalTranscript = '';
            }
            this.recognition.stop();
        } else {
            // 清除之前的延迟发送定时器
            if (this.sendTimeout) {
                clearTimeout(this.sendTimeout);
                this.sendTimeout = null;
            }
            this.lastFinalTranscript = '';
            try {
                this.recognition.start();
            } catch (error) {
                console.error('启动语音识别失败:', error);
            }
        }
    }
    
    sendRecognizedMessage(transcript) {
        if (!transcript || !transcript.trim()) {
            return;
        }
        
        // 标记不再是从"开始对话"触发（因为已经有结果了）
        this.isStartingChat = false;
        
        // 添加用户消息
        this.addMessage(transcript, 'user');
        
        // 更新状态
        this.updateRobotStatus('识别完成，正在发送...');
        
        // 发送消息
        this.sendMessageDirectly(transcript);
        
        // 停止语音识别（因为已经发送了消息）
        if (this.isRecording && this.recognition) {
            this.recognition.stop();
        }
    }

    updateVoiceButton(isRecording) {
        const voiceBtn = document.getElementById('robotVoiceBtn');
        if (!voiceBtn) return;

        if (isRecording) {
            voiceBtn.classList.add('recording');
            voiceBtn.querySelector('i').className = 'fas fa-stop';
        } else {
            voiceBtn.classList.remove('recording');
            voiceBtn.querySelector('i').className = 'fas fa-microphone';
        }
    }

    updateRobotStatus(text, listening = false) {
        const statusEl = document.getElementById('robotStatus');
        if (!statusEl) return;

        const statusText = statusEl.querySelector('.status-text');
        if (statusText) {
            statusText.textContent = text;
        }

        if (listening) {
            statusEl.classList.add('listening');
        } else {
            statusEl.classList.remove('listening');
        }
    }

    async sendMessage() {
        const input = document.getElementById('robotInput');
        let message = input?.value.trim();

        if (!message) return;

        // 处理"你好"后的内容提取（与语音识别保持一致）
        const processedMessage = this.extractContentAfterGreeting(message);
        
        // 如果处理后不为空，说明"你好"后面有其他内容，使用处理后的内容
        // 如果处理后为空，说明只有"你好"，使用原消息
        if (processedMessage && processedMessage.trim().length > 0) {
            message = processedMessage;
        }
        // 如果processedMessage为空，说明只有"你好"，保持原message不变

        // 添加用户消息（如果还没有添加）
        const messagesContainer = document.getElementById('chatMessages');
        const userMessages = messagesContainer?.querySelectorAll('.user-message');
        const lastUserMessage = userMessages?.[userMessages.length - 1];
        if (!lastUserMessage || lastUserMessage.textContent.trim() !== message) {
            this.addMessage(message, 'user');
        }
        
        // 清空输入框
        if (input) {
            input.value = '';
            // 重置 textarea 高度
            if (input.tagName === 'TEXTAREA') {
                input.style.height = 'auto';
            }
        }
        
        // 隐藏开始对话按钮（用户已开始对话）
        this.hideStartChatButton();
        
        // 关闭浮动输入框
        this.hideFloatingInput();

        // 发送消息
        await this.sendMessageDirectly(message);
    }
    
    async sendMessageDirectly(message) {
        if (!message || !message.trim()) return;

        // 显示加载状态
        this.setLoading(true);
        this.updateRobotStatus('思考中...');

        try {
            // 调用后端API
            const response = await fetch('/api/chat', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    user_id: 'robot_user',
                    message: message.trim()
                })
            });

            const data = await response.json();

            if (data.status === 'success') {
                // 添加机器人回复
                this.addMessage(data.answer_markdown, 'robot');
                this.updateRobotStatus('就绪');
                
                // 如果开启了语音播报，朗读回复内容
                if (this.ttsEnabled) {
                    // 延迟一下，让消息先显示，并且确保不在录音中
                    setTimeout(() => {
                        if (!this.isRecording) {
                            this.speak(data.answer_markdown);
                        }
                    }, 500);
                }
                
                // 消息发送成功后，延迟显示"开始对话"按钮，方便用户继续对话
                setTimeout(() => {
                    this.showStartChatButton();
                }, 2000);
            } else {
                this.addMessage('抱歉，处理您的问题时出现错误：' + data.message, 'robot');
                this.updateRobotStatus('错误');
            }
        } catch (error) {
            console.error('API调用错误:', error);
            this.addMessage('抱歉，网络连接出现问题，请稍后重试。', 'robot');
            this.updateRobotStatus('网络错误');
        } finally {
            this.setLoading(false);
            setTimeout(() => {
                this.updateRobotStatus('就绪');
            }, 1000);
        }
    }

    addMessage(content, type) {
        const messagesContainer = document.getElementById('chatMessages');
        if (!messagesContainer) return;

        const messageDiv = document.createElement('div');
        messageDiv.className = `message ${type}-message`;

        const avatar = type === 'robot' 
            ? '<i class="fas fa-robot"></i>' 
            : '<i class="fas fa-user"></i>';

        // 简单的Markdown转HTML（可以后续增强）
        const htmlContent = this.formatMessage(content);

        messageDiv.innerHTML = `
            <div class="message-content">
                <div class="message-avatar">${avatar}</div>
                <div class="message-text">${htmlContent}</div>
            </div>
        `;

        messagesContainer.appendChild(messageDiv);
        this.scrollToBottom();
        
        // 如果添加了用户消息，确保按钮隐藏
        if (type === 'user') {
            this.hideStartChatButton();
        }
    }

    formatMessage(content) {
        if (!content) return '';
        
        // 简单的Markdown格式化
        let html = content;
        
        // 代码块处理
        html = html.replace(/```(\w+)?\n?([\s\S]*?)```/g, (match, lang, code) => {
            const escapedCode = this.escapeHtml(code.trim());
            return `<pre><code class="language-${lang || 'text'}">${escapedCode}</code></pre>`;
        });
        
        // 行内代码
        html = html.replace(/`([^`]+)`/g, (match, code) => {
            return `<code>${this.escapeHtml(code)}</code>`;
        });
        
        // 标题
        html = html.replace(/^### (.*$)/gm, '<h3>$1</h3>');
        html = html.replace(/^## (.*$)/gm, '<h2>$1</h2>');
        html = html.replace(/^# (.*$)/gm, '<h1>$1</h1>');
        
        // 粗体和斜体
        html = html.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
        html = html.replace(/\*(.*?)\*/g, '<em>$1</em>');
        
        // 列表
        const lines = html.split('\n');
        let inList = false;
        let result = [];
        
        for (let line of lines) {
            const listMatch = line.match(/^[-*] (.*)$/) || line.match(/^\d+\. (.*)$/);
            if (listMatch) {
                if (!inList) {
                    result.push('<ul>');
                    inList = true;
                }
                result.push(`<li>${listMatch[1]}</li>`);
            } else {
                if (inList) {
                    result.push('</ul>');
                    inList = false;
                }
                if (line.trim()) {
                    result.push(line);
                }
            }
        }
        if (inList) {
            result.push('</ul>');
        }
        
        html = result.join('\n');
        
        // 段落处理
        html = html.split('\n\n').map(para => {
            para = para.trim();
            if (!para) return '';
            if (para.startsWith('<h') || para.startsWith('<ul') || para.startsWith('<pre')) {
                return para;
            }
            return `<p>${para}</p>`;
        }).join('');
        
        // 单换行转<br>
        html = html.replace(/\n/g, '<br>');
        
        return html;
    }

    escapeHtml(text) {
        const div = document.createElement('div');
        div.textContent = text;
        return div.innerHTML;
    }

    scrollToBottom() {
        const messagesContainer = document.getElementById('chatMessages');
        if (messagesContainer) {
            messagesContainer.scrollTop = messagesContainer.scrollHeight;
        }
    }

    setLoading(loading) {
        this.isLoading = loading;
        const loadingIndicator = document.getElementById('loadingIndicator');
        const sendBtn = document.getElementById('robotSendBtn');
        const input = document.getElementById('robotInput');

        if (loadingIndicator) {
            loadingIndicator.style.display = loading ? 'block' : 'none';
        }

        if (sendBtn) {
            sendBtn.disabled = loading;
        }

        if (input) {
            input.disabled = loading;
        }
    }

    focusInput() {
        const input = document.getElementById('robotInput');
        if (input) {
            setTimeout(() => {
                input.focus();
            }, 100);
        }
    }

    startChat() {
        const startChatBtn = document.getElementById('startChatBtn');
        
        // 添加点击动画效果
        if (startChatBtn) {
            startChatBtn.classList.add('clicked');
            setTimeout(() => {
                startChatBtn.classList.remove('clicked');
            }, 500);
        }
        
        // 更新机器人状态
        this.updateRobotStatus('准备对话...');
        
        // 隐藏开始对话按钮
        this.hideStartChatButton();
        
        // 清除之前的延迟发送定时器和识别结果（开始新的识别会话）
        if (this.sendTimeout) {
            clearTimeout(this.sendTimeout);
            this.sendTimeout = null;
        }
        this.lastFinalTranscript = '';
        
        // 优先尝试语音识别，如果不支持或失败，则显示浮动输入框
        if (this.recognition) {
            // 支持语音识别，直接启动
            try {
                this.updateRobotStatus('正在启动语音识别...');
                // 标记这是从"开始对话"按钮触发的
                this.isStartingChat = true;
                this.recognition.start();
                return;
            } catch (error) {
                console.log('语音识别启动失败，使用文字输入:', error);
                this.isStartingChat = false;
            }
        } else {
            this.isStartingChat = false;
        }
        
        // 不支持语音识别或启动失败，显示浮动输入框
        this.showFloatingInput();
    }
    
    showFloatingInput() {
        // 检查浮动输入框是否已存在
        let floatingInput = document.getElementById('floatingInputContainer');
        if (floatingInput) {
            const input = document.getElementById('robotInput');
            if (input) {
                input.focus();
            }
            return;
        }
        
        // 创建浮动输入框
        floatingInput = document.createElement('div');
        floatingInput.id = 'floatingInputContainer';
        floatingInput.className = 'floating-input-container';
        
        floatingInput.innerHTML = `
            <div class="floating-input-wrapper">
                <div class="floating-input-header">
                    <span>请输入你的问题</span>
                    <button class="floating-close-btn" id="floatingCloseBtn">
                        <i class="fas fa-times"></i>
                    </button>
                </div>
                <div class="floating-input-body">
                    <textarea 
                        id="robotInput" 
                        class="floating-input" 
                        placeholder="问我任何关于Rust的问题..."
                        rows="3"
                        autocomplete="off"></textarea>
                </div>
                <div class="floating-input-footer">
                    <button class="floating-voice-btn" id="robotVoiceBtn" title="语音输入">
                        <i class="fas fa-microphone"></i>
                        <span>语音输入</span>
                    </button>
                    <button class="floating-send-btn" id="robotSendBtn">
                        <i class="fas fa-paper-plane"></i>
                        <span>发送</span>
                    </button>
                </div>
            </div>
        `;
        
        // 添加到页面
        document.body.appendChild(floatingInput);
        
        // 绑定事件
        this.bindFloatingInputEvents();
        
        // 聚焦输入框
        setTimeout(() => {
            const input = document.getElementById('robotInput');
            if (input) {
                input.focus();
            }
        }, 100);
        
        // 更新状态
        this.updateRobotStatus('等待输入...');
    }
    
    bindFloatingInputEvents() {
        const input = document.getElementById('robotInput');
        const sendBtn = document.getElementById('robotSendBtn');
        const voiceBtn = document.getElementById('robotVoiceBtn');
        const closeBtn = document.getElementById('floatingCloseBtn');
        
        // 关闭按钮
        if (closeBtn) {
            closeBtn.addEventListener('click', () => {
                this.hideFloatingInput();
                this.showStartChatButton();
            });
        }
        
        // 输入框事件
        if (input) {
            input.addEventListener('keydown', (e) => {
                // Ctrl+Enter 或 Cmd+Enter 发送
                if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
                    e.preventDefault();
                    this.sendMessage();
                }
                // Escape 关闭
                if (e.key === 'Escape') {
                    this.hideFloatingInput();
                    this.showStartChatButton();
                }
            });
            
            input.addEventListener('input', () => {
                // 自动调整高度
                input.style.height = 'auto';
                input.style.height = input.scrollHeight + 'px';
            });
        }
        
        // 发送按钮
        if (sendBtn) {
            sendBtn.addEventListener('click', () => {
                this.sendMessage();
            });
        }
        
        // 语音输入按钮
        if (voiceBtn) {
            voiceBtn.addEventListener('click', () => {
                this.toggleVoiceInput();
            });
        }
        
        // 点击背景关闭
        const container = document.getElementById('floatingInputContainer');
        if (container) {
            container.addEventListener('click', (e) => {
                if (e.target === container) {
                    this.hideFloatingInput();
                    this.showStartChatButton();
                }
            });
        }
    }
    
    hideFloatingInput() {
        const floatingInput = document.getElementById('floatingInputContainer');
        if (floatingInput) {
            floatingInput.style.opacity = '0';
            floatingInput.style.transform = 'scale(0.9)';
            setTimeout(() => {
                floatingInput.remove();
            }, 300);
        }
    }
    
    bindInputEvents() {
        const input = document.getElementById('robotInput');
        const sendBtn = document.getElementById('robotSendBtn');
        const voiceBtn = document.getElementById('robotVoiceBtn');
        
        // 输入框回车发送
        if (input) {
            input.addEventListener('keypress', (e) => {
                if (e.key === 'Enter' && !e.shiftKey) {
                    e.preventDefault();
                    this.sendMessage();
                }
            });
            
            // 输入框获得焦点
            input.addEventListener('focus', () => {
                this.updateRobotStatus('输入中...');
                this.hideStartChatButton();
            });
            
            // 当用户输入内容时，隐藏按钮
            input.addEventListener('input', () => {
                if (input.value.trim().length > 0) {
                    this.hideStartChatButton();
                } else {
                    // 如果输入框被清空，检查是否有对话历史
                    const messagesContainer = document.getElementById('chatMessages');
                    if (messagesContainer) {
                        const userMessages = messagesContainer.querySelectorAll('.user-message');
                        // 如果只有欢迎消息，没有用户消息，可以显示按钮
                        if (userMessages.length === 0) {
                            this.showStartChatButton();
                        }
                    }
                }
            });
            
            input.addEventListener('blur', () => {
                if (!this.isRecording && !this.isLoading) {
                    this.updateRobotStatus('就绪');
                }
            });
        }
        
        // 发送按钮
        if (sendBtn) {
            sendBtn.addEventListener('click', () => {
                this.sendMessage();
            });
        }
        
        // 语音输入按钮
        if (voiceBtn) {
            voiceBtn.addEventListener('click', () => {
                this.toggleVoiceInput();
            });
        }
    }

    hideStartChatButton() {
        const startChatBtn = document.getElementById('startChatBtn');
        const startChatSection = startChatBtn?.parentElement;
        if (startChatSection) {
            startChatSection.style.opacity = '0';
            startChatSection.style.transform = 'translateY(-20px)';
            startChatSection.style.transition = 'all 0.3s ease';
            setTimeout(() => {
                startChatSection.style.display = 'none';
            }, 300);
        }
    }

    showStartChatButton() {
        const startChatBtn = document.getElementById('startChatBtn');
        const startChatSection = startChatBtn?.parentElement;
        if (startChatSection) {
            startChatSection.style.display = 'flex';
            setTimeout(() => {
                startChatSection.style.opacity = '1';
                startChatSection.style.transform = 'translateY(0)';
            }, 10);
        }
    }
}

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', () => {
    window.robotAssistant = new RobotAssistant();
});

